<!DOCTYPE html>
<html>

<head>
    <meta charset="utf-8" />
    <script type="module">


        // const mycallback = function mycallback(result) {
        //     console.log(result);
        //     return result;

        // }

        // async function myfun1(c) {

        //     return await new Promise(function (resolve, reject) {
        //         setTimeout(() => {
        //             // setTimeout 定时器线程去执行
        //             // 浏览器有各种各样的线程,比如事件触发器，网络请求,定时器等等.线程的联系都是基于事件的。
        //             let startTime = Date.now();
        //             for (let i = 0; i < 3000; i++) {
        //                 console.log("f1");
        //             }
        //             let rtime = Date.now() - startTime;
        //             resolve(c("myfun1" + "总耗时" + String(rtime) + " ms"));
        //         }, 20);
        //     });

        // }
        // async function myfun2(c) {

        //     return await new Promise(function (resolve, reject) {
        //         setTimeout(() => {
        //             let startTime = Date.now();
        //             for (let i = 0; i < 3000; i++) {
        //                 console.log("f2");
        //             }
        //             let rtime = Date.now() - startTime;
        //             resolve(c("myfun2" + "总耗时" + String(rtime) + " ms"));
        //         }, 20);
        //     });
        // }
        // async function f() {
        //     let startTime = Date.now();
        //     // myfun1(mycallback);
        //     // myfun2(mycallback);
        //     let [foo, bar] = await Promise.all([myfun1(mycallback), myfun2(mycallback)]);
        //     let rtime = Date.now() - startTime;
        //     console.log("总耗时", (rtime - 20), " ms -->> setTimeout会在浏览器中定时器线程中运行，所以类似于多线程！");
        // }
        // f();


        // import { threadsleep } from "./common.js";
        // // 代getFoo和getBar是两个独立的异步操作（即互不依赖），被写成继发关系。
        // // 这样比较耗时，因为只有getFoo完成以后，才会执行getBar，完全可以让它们同时触发。
        // async function getFoo() {
        //     let foo = await new Promise(function (resolve, reject) {
        //         threadsleep(5000).then((stime) => {
        //             // 这里实现了睡眠2秒
        //             resolve("getFoo: end after " + stime + " ms");
        //         });
        //     });
        //     return foo;
        // }

        // async function getBar() {
        //     let bar = await new Promise(function (resolve, reject) {
        //         threadsleep(2000).then((stime) => {
        //             // 这里实现了睡眠2秒
        //             resolve("getBar end after " + stime + " ms");
        //         });
        //     });
        //     return bar;
        // }

        // async function f() {
        //     // 写法一（
        //     let startTime = Date.now();
        //     let [foo, bar] = await Promise.all([getFoo(), getBar()]);
        //     let rtime = Date.now() - startTime;
        //     console.log([foo, bar], "总耗时" + rtime + " ms");

        //     // // 写法二
        //     // let fooPromise = getFoo();
        //     // let barPromise = getBar();
        //     // let foo = await fooPromise;
        //     // let bar = await barPromise;
        // }
        // f();



        // 如果await后面的异步操作出错，那么等同于async函数返回的 Promise 对象被reject。
        // async function f() {
        //     await new Promise(function (resolve, reject) {
        //         throw new Error('出错了');
        //     });
        // }
        // f()
        //     .then(
        //         v =>
        //             console.log(v)
        //     )
        //     .catch(e =>
        //         console.log(e)
        //     )
        // Error：出错了



        // function Sleep(interval) {
        //     return new Promise((resolve, reject) => {
        //         setTimeout(() => {
        //             resolve("OK")
        //         }, interval);
        //     });
        // }

        // // async函数返回的 Promise 对象，必须等到内部所有await命令后面的
        // // Promise 对象执行完，才会发生状态改变，除非遇到return语句或者抛出错误。
        // // 也就是说，只有async函数内部的异步操作执行完，才会执行then方法指定的回调函数。
        // async function ThreadSleep() {
        //     let result = await Sleep(1000);
        //     result = await Sleep(1000);
        //     result = await Sleep(1000);
        //     result = await Sleep(1000);
        //     result = await Sleep(1000);
        //     return result;
        // }
        // ThreadSleep().then((result) => {
        //     console.log(result);
        // })


        // class Sleep {
        //     constructor(timeout) {
        //         this.timeout = timeout;
        //         this.mSleepTime = 0;
        //     }
        //     then(resolve, reject) {
        //         const startTime = Date.now();
        //         let that = this;
        //         setTimeout(
        //             () => {
        //                 that.mSleepTime = Date.now() - startTime;
        //                 resolve(that.sleeptime);
        //             },
        //             that.timeout
        //         );
        //     }
        //     get sleeptime() { return this.mSleepTime }

        // }

        // let threadsleep = async (mtime) => {
        //     const sleepTime = await new Sleep(mtime);
        //     return sleepTime;
        // };

        // console.log("start");
        // threadsleep(2000).then((value) => {
        //     // 这里实现了睡眠2秒
        //     console.log("end after", value, "ms");
        // });
        // console.log("main end!");



        // const myasyncfun = async function test() {

        //     let a = await new Promise((resolve) => {
        //         setTimeout(() => {
        //             // 如果不执行resolve，a就不会有值;
        //             resolve("11")  // 如果不执行resolve，就不会执行下面代码的 let b = await 2....;
        //         }, 5000);
        //     });
        //     let b = await 2;
        //     let c = await 3;
        //     // return 4;
        //     return Promise.resolve(4);
        // }

        // console.log(myasyncfun());// async 会自动包装成promise
        // myasyncfun().then((value) => { // 如果不执行resolve，就不会执行then
        //     console.log(value);
        // })




        // // sync函数返回一个 Promise 对象。
        // // async函数内部return语句返回的值，会成为then方法回调函数的参数。
        //         async function timeout(ms) {// async 会自动包装成promise
        //             let result = await new Promise((resolve, reject) => {
        //                 setTimeout((resolve("11")), ms); // 如果不执行resolve，就不会执行下面的return result;
        //             });
        //            return result;
        //         }

        //         async function asyncPrint(value, ms) {
        //             console.log(timeout(ms));// promise
        //             let asynctimeout = await timeout(ms); // asynctimeout-->async timeout所代表的promise执行的值==上面的result
        //             console.log(asynctimeout);
        //             console.log(value);
        //         }
        //         asyncPrint('hello world', 50);

        // function timeout(ms) {
        //     return new Promise((resolve,reject) => {
        //         setTimeout((resolve), ms);
        //     });
        // }

        // async function asyncPrint(value, ms) {
        //     await timeout(ms);
        //     console.log(value);
        // }
        // -----------------------------------------------------------------------------
        // asyncPrint('hello world', 50);

        async function afunc() {
            console.log("aaaaa---------------");

            let await1 = await new Promise(
                function (resolve, reject) {

                    setTimeout(function () {
                        console.log("ccccc");
                        resolve("OK");
                        console.log("ccccc2");
                    }, 1000);

                }).then(function (value) {
                    console.log("ddddd");
                });

            // 不加resolve 不会执行下面的部分
            console.log(await1);// await1==ok
            console.log("ddddd2");

        }

        let async1 = afunc();
        console.log(async1);// async1返回值是个承诺

        // let arr = new Array(100);
        // arr.fill(7);
        // for (let i = 0; i < arr.length; i++) {
        //     console.log(arr[i]);
        // }

        // console.log("bbbbb");


    </script>
</head>

<body>

</body>

</html>